package Gui;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.filechooser.FileFilter;

import FunkcjePrzynaleznosci.GaussowskaFunkcjaPrzynaleznosci;
import FunkcjePrzynaleznosci.IFunkcjaPrzynaleznosci;
import FunkcjePrzynaleznosci.ProstokatnaFunkcjaPrzynaleznosci;
import FunkcjePrzynaleznosci.TrapezoidalnaFunkcjaPrzynaleznosci;
import FunkcjePrzynaleznosci.TrojkatnaFunkcjaPrzynaleznosci;
import Gui.FiltryPlikow.FiltrPlikowTekstowych;
import Gui.FiltryPlikow.FiltrPlikowXml;
import Gui.Modele.ModelSkladnikowPodsumowania;
import Gui.Modele.ModelTabeliPodsumowan;
import Narzedzia.KazdyZKazdym;
import PodsumowaniaLingwistyczne.IKwalifikator;
import PodsumowaniaLingwistyczne.IKwalifikatorTypu2;
import PodsumowaniaLingwistyczne.ISumaryzator;
import PodsumowaniaLingwistyczne.ISumaryzatorTypu2;
import PodsumowaniaLingwistyczne.Kwalifikator;
import PodsumowaniaLingwistyczne.KwalifikatorTypu2;
import PodsumowaniaLingwistyczne.Kwantyfikator;
import PodsumowaniaLingwistyczne.MiaryTypu2;
import PodsumowaniaLingwistyczne.PodsumowanieTypu2;
import PodsumowaniaLingwistyczne.Sumaryzator;
import PodsumowaniaLingwistyczne.SumaryzatorTypu2;
import PrzestrzenCiagla.CiaglyZbiorRozmyty;
import PrzestrzenCiagla.DopelnienieCiaglyZbiorRozmyty;
import PrzestrzenCiagla.PrzestrzenCiagla;
import PrzestrzenCiagla.ZbiorRozmytyTypu2;
import PrzestrzenDyskretna.PrzestrzenDyskretna;
import ZmiennaLingwistyczna.ModyfikatorLingwistyczny;
import ZmiennaLingwistyczna.WartoscLingwistyczna;
import ZmiennaLingwistyczna.WartoscLingwistycznaTypu2;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

import csvIO.CsvIO;
import csvIO.CsvObject;
import csvIO.CsvRow;

public class ObslugaAplikacji {

	// ============= POLA KLASY
	private static ObslugaAplikacji instancja = null;
	private FrameGlowneOkno okno;
	private CsvObject bazaDanych;
	private ModelSkladnikowPodsumowania skladnikiPodsumowania;
	private List<ISumaryzator> listaSumaryzatorow;
	private List<IKwalifikator> listaKwalifikatorow;
	private List<Kwantyfikator> listaKwantyfikatorow;
	private List<ISumaryzatorTypu2> listaSumaryzatorowTypu2;
	private List<IKwalifikatorTypu2> listaKwalifikatorowTypu2;

	// ============= KONSTRUKTOR i WLASCIWOSCI =================
	protected ObslugaAplikacji() {
		listaSumaryzatorow = new ArrayList<ISumaryzator>();
		listaKwalifikatorow = new ArrayList<IKwalifikator>();
		listaKwantyfikatorow = new ArrayList<Kwantyfikator>();
		listaSumaryzatorowTypu2 = new ArrayList<ISumaryzatorTypu2>();
		listaKwalifikatorowTypu2 = new ArrayList<IKwalifikatorTypu2>();
	}

	// ------------------------------------------------------------------------------
	public static ObslugaAplikacji wezInstancje() {
		if (instancja == null) {
			instancja = new ObslugaAplikacji();
		}
		return instancja;
	}

	// ------------------------------------------------------------------------------
	public FrameGlowneOkno getGlowneOknoAplikacji() {
		return okno;
	}

	// ------------------------------------------------------------------------------
	public void setGlowneOknoAplikacji(FrameGlowneOkno okno) {
		this.okno = okno;
		this.skladnikiPodsumowania = okno.getModelSkladnikowPodsumowania();
	}

	// ============= OBSLUGA AKCJI MENU ========================
	public void wygenerujPodsumowania() {
		if (bazaDanych == null) {
			pokazBlad("Baza danych nie zostala wczytana");
			return;
		}
		List<Kwantyfikator> zaznaczoneKwantyfikatory = skladnikiPodsumowania.pobierzZaznaczoneKwantyfikatory();
		if (zaznaczoneKwantyfikatory.size() == 0) {
			pokazBlad("Nie zaznaczono żadnego kwantyfikatora");
			return;
		}
		List<ISumaryzatorTypu2> zaznaczoneSumaryzatory = skladnikiPodsumowania.pobierzZaznaczoneSumaryzatory();
		if (zaznaczoneSumaryzatory.size() == 0) {
			pokazBlad("Nie zaznaczono żadnego sumaryzatora");
			return;
		}
		List<IKwalifikatorTypu2> zaznaczoneKwalifikatory = skladnikiPodsumowania.pobierzZaznaczoneKwalifikatory();

		List<Kwantyfikator> dostepneKwantyfikatory = zaznaczoneKwantyfikatory;
		List<IKwalifikatorTypu2> dostepneKwalifikatory = kombinacjeKwalifikatorow(zaznaczoneKwalifikatory);
		List<ISumaryzatorTypu2> dostepneSumaryzatory = kombinacjeSumaryzatorow(zaznaczoneSumaryzatory);

		List<PodsumowanieTypu2> listaPodsumowan = new ArrayList<PodsumowanieTypu2>();
		float[] wagiOcen = okno.getWagi();

		PodsumowanieTypu2 podsumowanie;
		for (Kwantyfikator Q : dostepneKwantyfikatory) {
			for (ISumaryzatorTypu2 S : dostepneSumaryzatory) {
				podsumowanie = new PodsumowanieTypu2(S, Q);
				MiaryTypu2.ocen(podsumowanie, bazaDanych, wagiOcen);
				listaPodsumowan.add(podsumowanie);
				for (IKwalifikatorTypu2 W : dostepneKwalifikatory) {
					podsumowanie = new PodsumowanieTypu2(S, Q, W);
					MiaryTypu2.ocen(podsumowanie, bazaDanych, wagiOcen);
					listaPodsumowan.add(podsumowanie);
				}
			}
		}
		ModelTabeliPodsumowan model = okno.getModelTabeliPodsumowan();
		model.setListaPodsumowan(listaPodsumowan);
		model.fireTableDataChanged();
		pokazInformacje("Wygenerowano podsumowania");

	}

	// ------------------------------------------------------------------------------
	private List<ISumaryzatorTypu2> konwertujSumaryzatoryTyp1NaTyp2(List<ISumaryzator> listaSumaryzatorow) {
		List<ISumaryzatorTypu2> lista2 = new ArrayList<ISumaryzatorTypu2>();
		for (ISumaryzator sumaryzator1 : listaSumaryzatorow) {
			ISumaryzatorTypu2 sumaryzator2 = new SumaryzatorTypu2(sumaryzator1);
			lista2.add(sumaryzator2);
		}
		return lista2;
	}

	// ------------------------------------------------------------------------------
	private List<IKwalifikatorTypu2> konwertujKwalifikatoryTyp1NaTyp2(List<IKwalifikator> listaKwalifikatorow) {
		List<IKwalifikatorTypu2> lista2 = new ArrayList<IKwalifikatorTypu2>();
		for (IKwalifikator kwalifikator1 : listaKwalifikatorow) {
			IKwalifikatorTypu2 kwalifikator2 = new KwalifikatorTypu2(kwalifikator1);
			lista2.add(kwalifikator2);
		}
		return lista2;
	}

	// ------------------------------------------------------------------------------
	public List<IKwalifikatorTypu2> kombinacjeKwalifikatorow(List<IKwalifikatorTypu2> lista) {
		return KazdyZKazdym.kwalifikatory(lista);
	}

	// ------------------------------------------------------------------------------
	public List<ISumaryzatorTypu2> kombinacjeSumaryzatorow(List<ISumaryzatorTypu2> lista) {
		return KazdyZKazdym.sumaryzatory(lista);
	}

	// ------------------------------------------------------------------------------
	public void dodajTestoweSkladniki() {
		PrzestrzenCiagla przestrzen = new PrzestrzenCiagla(0.0f, 50.0f, 0.1f);
		IFunkcjaPrzynaleznosci funkcja = new TrojkatnaFunkcjaPrzynaleznosci(0.0f, 4.0f, 8.0f);

		CiaglyZbiorRozmyty zbiorSumaryzator = new CiaglyZbiorRozmyty(przestrzen, funkcja);

		WartoscLingwistyczna wartoscSumaryzator = new WartoscLingwistyczna("niewielkie", zbiorSumaryzator);
		wartoscSumaryzator.setModyfikator(new ModyfikatorLingwistyczny("bardzo", 2.0f));

		ISumaryzator sumaryzator = new Sumaryzator(wartoscSumaryzator, 2);

		listaSumaryzatorow.add(sumaryzator);

		PrzestrzenCiagla przestrzenIlosc = new PrzestrzenCiagla(0.0f, 1.0f, 0.01f);

		IFunkcjaPrzynaleznosci funkcjaNiewiele = new TrapezoidalnaFunkcjaPrzynaleznosci(0.0f, 0.0f, 0.15f, 0.2f);

		CiaglyZbiorRozmyty zbiorNiewiele = new CiaglyZbiorRozmyty(przestrzenIlosc, funkcjaNiewiele);

		WartoscLingwistyczna wartoscNiewiele = new WartoscLingwistyczna("niewiele", zbiorNiewiele);

		Kwantyfikator kwantyfikatorNiewiele = new Kwantyfikator(wartoscNiewiele, false);

		listaKwantyfikatorow.add(kwantyfikatorNiewiele);

		IFunkcjaPrzynaleznosci funkcjaSrednio = new TrapezoidalnaFunkcjaPrzynaleznosci(0.15f, 0.3f, 0.6f, 0.7f);

		CiaglyZbiorRozmyty zbiorSrednio = new CiaglyZbiorRozmyty(przestrzenIlosc, funkcjaSrednio);

		WartoscLingwistyczna wartoscSrednio = new WartoscLingwistyczna("srednio", zbiorSrednio);

		Kwantyfikator kwantyfikatorSrednio = new Kwantyfikator(wartoscSrednio, false);

		listaKwantyfikatorow.add(kwantyfikatorSrednio);

		IFunkcjaPrzynaleznosci funkcjaDuzo = new TrapezoidalnaFunkcjaPrzynaleznosci(0.68f, 0.8f, 1.0f, 1.0f);

		DopelnienieCiaglyZbiorRozmyty zbiorDuzo = new DopelnienieCiaglyZbiorRozmyty(new CiaglyZbiorRozmyty(
				przestrzenIlosc, funkcjaDuzo));

		WartoscLingwistyczna wartoscDuzo = new WartoscLingwistyczna("duzo", zbiorDuzo);

		Kwantyfikator kwantyfikatorDuzo = new Kwantyfikator(wartoscDuzo, false);

		kwantyfikatorDuzo.setModyfikator(new ModyfikatorLingwistyczny("bardzo", 2.0f));

		listaKwantyfikatorow.add(kwantyfikatorDuzo);

		PrzestrzenCiagla przestrzenKwalifikator = new PrzestrzenCiagla(0.0f, 400.0f, 0.1f);
		IFunkcjaPrzynaleznosci funkcjaKwalifikator = new TrapezoidalnaFunkcjaPrzynaleznosci(100.0f, 120.0f, 170.0f,
				190.0f);
		CiaglyZbiorRozmyty zbiorKwalifikator = new CiaglyZbiorRozmyty(przestrzenKwalifikator, funkcjaKwalifikator);
		WartoscLingwistyczna wartoscSredniaOdleglosc = new WartoscLingwistyczna("sredniaOdleglosc", zbiorKwalifikator);
		IKwalifikator kwalifikator = new Kwalifikator(wartoscSredniaOdleglosc, 3);

		listaKwalifikatorow.add(kwalifikator);

		listaSumaryzatorowTypu2 = konwertujSumaryzatoryTyp1NaTyp2(listaSumaryzatorow);

		listaKwalifikatorowTypu2 = konwertujKwalifikatoryTyp1NaTyp2(listaKwalifikatorow);
	}

	// ------------------------------------------------------------------------------
	public void zapiszKonfiguracje(String sciezka) {

		try {
			PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(sciezka),
					"UTF-8")));

			XStream xstream = mapowanieXml();
			pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
			ObjectOutputStream out = xstream.createObjectOutputStream(pw, "SkladnikiPodsumowania");
			xstream.alias("ListaKwantyfikatorow", List.class);
			out.writeObject(listaKwantyfikatorow);

			xstream.alias("ListaKwalifikatorow", List.class);
			out.writeObject(listaKwalifikatorow);
			xstream.alias("ListaKwalifikatorowTypu2", List.class);
			out.writeObject(listaKwalifikatorowTypu2);

			xstream.alias("ListaSumaryzatorow", List.class);
			out.writeObject(listaSumaryzatorow);
			xstream.alias("ListaSumaryzatorowTypu2", List.class);
			out.writeObject(listaSumaryzatorowTypu2);

			out.close();
		} catch (Exception e) {
			pokazBlad("Wystapil blad podczas zapisywania konfiguracji do pliku: \n" + e.getMessage());
		}
	}

	// ------------------------------------------------------------------------------
	public void wczytajKonfiguracje() {

		String sciezka = przegladajPliki(new FiltrPlikowXml());
		if (sciezka != null) {
			try {
				Reader rdr = new BufferedReader(new InputStreamReader(new FileInputStream(sciezka), "UTF-8"));

				XStream xstream = mapowanieXml();

				ObjectInputStream in = xstream.createObjectInputStream(rdr);
				xstream.alias("ListaKwantyfikatorow", List.class);
				listaKwantyfikatorow = (List<Kwantyfikator>) in.readObject();

				xstream.alias("ListaKwalifikatorow", List.class);
				listaKwalifikatorow = (List<IKwalifikator>) in.readObject();
				xstream.alias("ListaKwalifikatorowTypu2", List.class);
				listaKwalifikatorowTypu2 = (List<IKwalifikatorTypu2>) in.readObject();

				xstream.alias("ListaSumaryzatorow", List.class);
				listaSumaryzatorow = (List<ISumaryzator>) in.readObject();
				xstream.alias("ListaSumaryzatorowTypu2", List.class);
				listaSumaryzatorowTypu2 = (List<ISumaryzatorTypu2>) in.readObject();

				in.close();
				skladnikiPodsumowania.wyczysc();
				List<ISumaryzatorTypu2> listaKonwertowanychSumaryzatorow = konwertujSumaryzatoryTyp1NaTyp2(listaSumaryzatorow);
				List<IKwalifikatorTypu2> listaKonwertowanychKwalifikatorow = konwertujKwalifikatoryTyp1NaTyp2(listaKwalifikatorow);

				listaSumaryzatorowTypu2.addAll(listaKonwertowanychSumaryzatorow);
				listaKwalifikatorowTypu2.addAll(listaKonwertowanychKwalifikatorow);

				for (ISumaryzatorTypu2 sumaryzator : listaSumaryzatorowTypu2) {
					skladnikiPodsumowania.dodajSumaryzator(sumaryzator);
				}
				for (IKwalifikatorTypu2 kwalifikator : listaKwalifikatorowTypu2) {
					skladnikiPodsumowania.dodajKwalifikator(kwalifikator);
				}
				for (Kwantyfikator kwantyfikator : listaKwantyfikatorow) {
					skladnikiPodsumowania.dodajKwantyfikator(kwantyfikator);
				}
				skladnikiPodsumowania.odswiez();
			} catch (Exception e) {
				pokazBlad("Wystapil blad podczas wczytywania konfiguracji z pliku: \n" + e.getMessage());
			}
		}

	}

	// ------------------------------------------------------------------------------
	private XStream mapowanieXml() {
		XStream xstream = new XStream(new DomDriver("Unicode"));

		// Funkcje przynaleznosci
		xstream.alias("Gaussowska", GaussowskaFunkcjaPrzynaleznosci.class);
		xstream.useAttributeFor(GaussowskaFunkcjaPrzynaleznosci.class, "srodek");
		xstream.useAttributeFor(GaussowskaFunkcjaPrzynaleznosci.class, "szerokosc");

		xstream.alias("Prostokatna", ProstokatnaFunkcjaPrzynaleznosci.class);
		xstream.useAttributeFor(ProstokatnaFunkcjaPrzynaleznosci.class, "a");
		xstream.useAttributeFor(ProstokatnaFunkcjaPrzynaleznosci.class, "d");

		xstream.alias("Trapezoidalna", TrapezoidalnaFunkcjaPrzynaleznosci.class);
		xstream.useAttributeFor(TrapezoidalnaFunkcjaPrzynaleznosci.class, "a");
		xstream.useAttributeFor(TrapezoidalnaFunkcjaPrzynaleznosci.class, "b");
		xstream.useAttributeFor(TrapezoidalnaFunkcjaPrzynaleznosci.class, "c");
		xstream.useAttributeFor(TrapezoidalnaFunkcjaPrzynaleznosci.class, "d");

		xstream.alias("Trojkatna", TrojkatnaFunkcjaPrzynaleznosci.class);
		xstream.useAttributeFor(TrojkatnaFunkcjaPrzynaleznosci.class, "a");
		xstream.useAttributeFor(TrojkatnaFunkcjaPrzynaleznosci.class, "b");
		xstream.useAttributeFor(TrojkatnaFunkcjaPrzynaleznosci.class, "c");

		// Zmienne lingwistyczne
		xstream.alias("ModyfikatorLingwistyczny", ModyfikatorLingwistyczny.class);
		xstream.aliasAttribute(ModyfikatorLingwistyczny.class, "wspolczynnik", "r");
		xstream.aliasAttribute(ModyfikatorLingwistyczny.class, "nazwa", "etykieta");

		xstream.alias("WartoscLingwistyczna", WartoscLingwistyczna.class);
		xstream.useAttributeFor(WartoscLingwistyczna.class, "etykieta");
		xstream.aliasField("Modyfikator", WartoscLingwistyczna.class, "modyfikator");
		xstream.aliasField("CiaglyZbiorRozmyty", WartoscLingwistyczna.class, "zbior");
		xstream.alias("WartoscLingwistycznaTypu2", WartoscLingwistycznaTypu2.class);
		xstream.useAttributeFor(WartoscLingwistycznaTypu2.class, "etykieta");
		xstream.aliasField("CiaglyZbiorRozmytyTypu2", WartoscLingwistycznaTypu2.class, "zbior");
		xstream.aliasField("Modyfikator", WartoscLingwistycznaTypu2.class, "modyfikator");

		// Zbiory i przestrzenie
		xstream.alias("CiaglyZbiorRozmyty", CiaglyZbiorRozmyty.class);
		xstream.alias("Dopelnienie", DopelnienieCiaglyZbiorRozmyty.class);
		xstream.alias("PrzestrzenCiagla", PrzestrzenCiagla.class);
		xstream.aliasField("PrzestrzenCiagla", CiaglyZbiorRozmyty.class, "przestrzen");
		xstream.aliasField("FunkcjaPrzynaleznosci", CiaglyZbiorRozmyty.class, "funkcjaPrzynaleznosci");
		xstream.useAttributeFor(PrzestrzenCiagla.class, "poczatek");
		xstream.useAttributeFor(PrzestrzenCiagla.class, "koniec");
		xstream.useAttributeFor(PrzestrzenCiagla.class, "krok");
		xstream.alias("PrzestrzenDyskretna", PrzestrzenDyskretna.class);

		xstream.alias("CiaglyZbiorRozmytyTypu2", ZbiorRozmytyTypu2.class);
		xstream.aliasField("PrzestrzenDrugorzedna", ZbiorRozmytyTypu2.class, "przestrzenZeroJeden");
		xstream.aliasField("BazowyZbiorRozmyty", ZbiorRozmytyTypu2.class, "bazowyZbiorRozmyty");
		xstream.aliasAttribute(ZbiorRozmytyTypu2.class, "funkcjaDrugorzednaTyp", "TypFunkcjiDrugorzednej");
		xstream.aliasAttribute(ZbiorRozmytyTypu2.class, "funkcjaDrugorzednaSzerokosc", "SzerokoscFunkcjiDrugorzednej");

		// Skladniki podsumowania
		xstream.alias("Kwalifikator", Kwalifikator.class);
		xstream.useAttributeFor(Kwalifikator.class, "indeksPolaKrotki");
		xstream.aliasField("WartoscLingwistyczna", Kwalifikator.class, "wartoscLingwistyczna");
		xstream.alias("KwalifikatorTypu2", KwalifikatorTypu2.class);
		xstream.useAttributeFor(KwalifikatorTypu2.class, "indeksPolaKrotki");
		xstream.aliasField("WartoscLingwistyczna", KwalifikatorTypu2.class, "wartoscLingwistyczna");

		xstream.alias("Kwantyfikator", Kwantyfikator.class);
		xstream.aliasField("Modyfikator", Kwantyfikator.class, "modyfikator");
		xstream.aliasField("CiaglyZbiorRozmyty", Kwantyfikator.class, "zbior");
		xstream.useAttributeFor(Kwantyfikator.class, "czyAbsolutny");

		xstream.alias("Sumaryzator", Sumaryzator.class);
		xstream.useAttributeFor(Sumaryzator.class, "indeksPolaKrotki");
		xstream.alias("SumaryzatorTypu2", SumaryzatorTypu2.class);
		xstream.useAttributeFor(SumaryzatorTypu2.class, "indeksPolaKrotki");
		xstream.aliasField("WartoscLingwistyczna", SumaryzatorTypu2.class, "wartoscLingwistyczna");

		// Dodatkowe mapowania
		xstream.alias("SkladnikiPodsumowania", ObslugaAplikacji.class);
		xstream.aliasField("ListaKwantyfikatorow", ObslugaAplikacji.class, "listaKwantyfikatorow");
		xstream.aliasField("ListaKwalifikatorow", ObslugaAplikacji.class, "listaKwalifikatorow");
		xstream.aliasField("ListaKwalifikatorowTypu2", ObslugaAplikacji.class, "listaKwalifikatorowTypu2");
		xstream.aliasField("ListaSumaryzatorow", ObslugaAplikacji.class, "listaSumaryzatorow");
		xstream.aliasField("ListaSumaryzatorowTypu2", ObslugaAplikacji.class, "listaSumaryzatorowTypu2");
		return xstream;
	}

	// ------------------------------------------------------------------------------
	public void wczytajBazeDanych() {
		String sciezka = przegladajPliki(new FiltrPlikowTekstowych());
		if (sciezka != null) {
			try {
				bazaDanych = (new CsvIO()).readCSV(sciezka, false);
//				int iloscKolumn = bazaDanych.getRowLength();
//				for (int i = 0; i < iloscKolumn; i++) {
//					System.out.println(minMaxKolumny(i, bazaDanych));;
//				}
				pokazInformacje("Wczytywanie bazy danych zakończone");
			} catch (Exception e) {
				pokazBlad("Wystpil blad podczas wczytywania bazy danych: \n\n" + e.getMessage());
			}
		}
	}

	public void pokazSzczegolyPodsumowania(int numerWiersza) {
		ModelTabeliPodsumowan model = okno.getModelTabeliPodsumowan();
		PodsumowanieTypu2 podsumowanie = model.getPodsumowanieTypu2(numerWiersza);
		if (podsumowanie == null) {
			return;
		}
		DialogSzczegolyPodsumowania szczegoly = okno.getOknoSzczegolyPodsumowania();
		IKwalifikatorTypu2 kwalifikator = podsumowanie.getKwalifikator();
		if(kwalifikator != null){
			szczegoly.ustawIloscKwalifikatorow(kwalifikator.getKwalifikatorySkladowe().size());
			szczegoly.ustawTekstKwalifikatora(kwalifikator.toString());
		}else {
			szczegoly.ustawIloscKwalifikatorow(0);
			szczegoly.ustawTekstKwalifikatora("BRAK");
		}
		ISumaryzatorTypu2 sumaryzator = podsumowanie.getSumaryzator();
		if(sumaryzator != null){
			szczegoly.ustawIloscSumaryzatorow(sumaryzator.getSumaryzatorySkladowe().size());
			szczegoly.ustawTekstSumaryzatora(sumaryzator.toString());
		}else {
			szczegoly.ustawIloscSumaryzatorow(0);
			szczegoly.ustawTekstSumaryzatora("BRAK");
		}
		Kwantyfikator kwantyfikator = podsumowanie.getKwantyfikator();
		if(kwantyfikator != null){
			szczegoly.ustawTekstKwantyfikatora(kwantyfikator.toString());
			szczegoly.ustawTypKwantyfikatora(kwantyfikator.isCzyAbsolutny());
		}else {
			szczegoly.ustawTekstKwantyfikatora("BRAK");
			szczegoly.ustawTypKwantyfikatora(false);
		}
		szczegoly.ustawMiary(podsumowanie.getOcena());
		szczegoly.setVisible(true);
	}

	// =========== METODY POMOCNICZE ========================
	public void pokazBlad(String tresc) {
		JOptionPane.showMessageDialog(okno, tresc, "Błąd!", JOptionPane.ERROR_MESSAGE);
	}

	// ------------------------------------------------------------------------------
	public void pokazInformacje(String tresc) {
		JOptionPane.showMessageDialog(okno, tresc, "Błąd!", JOptionPane.INFORMATION_MESSAGE);
	}

	// ------------------------------------------------------------------------------
	public int pokazPytanie(String tresc) {
		Object[] options = { "Tak", "Nie" };
		int n = JOptionPane.showOptionDialog(okno, tresc + "?", "Pytanie", JOptionPane.YES_NO_OPTION,
				JOptionPane.QUESTION_MESSAGE, null, options, options[0]);
		if (n == JOptionPane.YES_OPTION) {
			return 1;
		}
		return 0;
	}

	// ------------------------------------------------------------------------------
	public String przegladajPliki(FileFilter filtrPlikow) {

		JFileChooser fileChooser = new JFileChooser(".");
		fileChooser.setMultiSelectionEnabled(false);
		fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
		fileChooser.addChoosableFileFilter(filtrPlikow);
		fileChooser.setAcceptAllFileFilterUsed(false);
		int status = fileChooser.showOpenDialog(okno);
		if (status == JFileChooser.APPROVE_OPTION) {
			File plik = fileChooser.getSelectedFile();
			return plik.getAbsolutePath();
		}
		return null;
	}
	
	public String minMaxKolumny(int numerKolumny, CsvObject baza){
		
		double minimum = Double.MAX_VALUE;
		double maximum = Double.MIN_VALUE;
		
		for (CsvRow wiersz : baza.getRows()) {
			double wartosc = Double.parseDouble(wiersz.get(numerKolumny));
			if(wartosc < minimum){
				minimum = wartosc;
			}
			if(wartosc > maximum){
				maximum = wartosc;
			}
		}
		return "Kolumna "+numerKolumny+" : \n"+"MIN = "+minimum+"\nMAX = "+maximum+"\n";
	}

}
